package utils;

import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MyStringUtils {

	

	// --------------------------------------------------------------------
	// Splitten nach versch. Kriterien
	// --------------------------------------------------------------------

	private static Pattern patDollar = Pattern.compile(" *\\$ *" + "| *; *"
		+ "| */ *" + "| *, *");

	private static Pattern patEckigRechts = Pattern.compile("\\]");

	// Splittet nach ; / und $
	public static String[] splitString(String s) {
		if (s == null)
			return null;
		if (s.length() == 0)
			return null;
		return patDollar.split(s);
	}

	// --------------------------------------------------------------------

	private static Pattern patSlash = Pattern.compile(" / ");

	// Splittet nach /
	public static String[] splitSlash(String s) {
		if (s == null)
			return null;
		if (s.length() == 0)
			return null;
		return patSlash.split(s);
	}

	// --------------------------------------------------------------------

	// gibt Teilstring in eckiger Klammer und Teilstring außerhalb zurück
	public static String[] verarbeiteEckigeKlammern(String line) {
		if (line == null)
			return null;
		if (line.length() == 0)
			return null;
		if (line.charAt(0) == '[') {
			line = line.substring(1);
			return patEckigRechts.split(line);
		}
		return null;
	}

	// --------------------------------------------------------------------
	// IDN-Funktionen und Patterns
	// --------------------------------------------------------------------

	// Ein Vorschlag
	private static String teilstringVorIDN = "SET:";

	/**
	 * Setzt den Beginn der Kopfzeile fest.
	 * 
	 * Diese kann auch noch anders weitergehen.
	 * 
	 * @param s
	 */
	public static void setTeilstringVorIDN(String s) {
		if (s == null)
			return;
		teilstringVorIDN = s;
	}

	// Mindestens 7 Zahlen, gefolgt von word-char [a-zA-Z_0-9]
	private static Pattern pIDN = Pattern.compile("\\d{7,}\\w");

	/**
	 * Liefer die erkannte idn oder null.
	 * 
	 * Extrahiert aus der eingelesenen Kopfzeile die IDN.
	 * 
	 * Annahme: der Teilstring vor der IDN ist "SET:" (und geht noch anders
	 * weiter); das kann aber jederzeit über setTeilstringVorIDN(..) geändert
	 * werden.
	 * 
	 * @param line
	 *            Kopfzeile eines neuen Datensatzes
	 *            
	 * @return Gültige IDN oder null
	 */
	public static String extractIDN(String line) {
		if (!line.startsWith(teilstringVorIDN))
			return null;

		// nur nach dem Kopf nach IDN suchen
		line = line.substring(teilstringVorIDN.length());

		Matcher mIDN = pIDN.matcher(line);
		if (mIDN.find()) {
			// System.err.println(mIDN.group());
			return mIDN.group().trim();

		}
		return null;
	}

	/*
	 * Simuliert eine Kopfzeile, wie sie beim Download erzeugt wird
	 */
	public static String kopfzeile() {
		return "SET: S1 [14] TTL: 1           "
			+ "PPN: 972620788                            " + "SEITE1 .";
	}

	/*
	 * Simuliert eine Kopfzeile mit idn, wie sie beim Download erzeugt wird
	 */
	public static String kopfzeile(int nr, String idn) {
		return "SET: S1 [14] TTL: " + nr + "           " + "PPN: " + idn
			+ "                            " + "SEITE1 .";
	}

	// ----------------------------------------------------------------

	/**
	 * Gibt ein Array mit 2 Einträgen oder null.
	 */
	public static String[] extractIndikatorUndInhalt(String line) { //
		if (line == null)
			return null;
		if (line.length() < 3)
			return null;
		// korrekte |?
		if (line.charAt(0) != '|' || line.charAt(2) != '|')
			return null;
		String ss[] = new String[2];
		ss[0] = line.substring(1, 2);
		ss[1] = line.substring(3);

		return ss;
	}

		

	// ----------------------------------------------------------------

	private static Pattern patSonderzeichen = Pattern // ?
			.compile(".*[^@,\\s\\w<>äöüÄÖÜß§\\$%&-].*");

	public static boolean containsSonderzeichen(String s) {
		return patSonderzeichen.matcher(s).matches();
	}

	// -------------------------------------------------------------------

	private static Pattern patgezaehlteUnterabteilung = Pattern
			.compile("(.*-\\d*)");

	public static boolean containsGezUnterabt(String s) {
		return patgezaehlteUnterabteilung.matcher(s).matches();
	}

	

	/*
	 * Gibt einen Text mit Zeilenumbrüchen in vorgegebener Zeilenlänge zurück.
	 * Text darf noch keine Zeilenumbrüche enthalten.
	 */
	public static String maximaleZeilenlaenge(String s, int len) {
		StringTokenizer st = new StringTokenizer(s, " ", true);
		String word, ausgabe = "";
		int currentLineLen = 0;

		while (st.hasMoreTokens()) {
			word = st.nextToken();
			int wordLen = word.length();

			if (currentLineLen + wordLen <= len) {
				ausgabe += word;
				currentLineLen += wordLen;
			} else { // Zeilenumbruch erforderlich
				ausgabe += "\n";
				boolean firstIsSpace = (word.charAt(0) == ' ');
				ausgabe += (firstIsSpace ? "" : word);
				currentLineLen = firstIsSpace ? 0 : wordLen;
			}
		}
		return ausgabe;
	}

	/*
	 * Rückt Folgezeilen eines String um anz Tabs nach rechts.
	 */
	public static String folgezeilenEinruecken(String s, int anz) {
		StringBuffer ein = new StringBuffer("");
		for (int i = 0; i < anz; i++) {
			ein.append("\t");
		}
		String einrueckung = "\n" + ein.toString();
		// Ersetze alle "\n" durch "\n\t..."

		// s = s.replaceAll("\n", a);
		return s.replaceAll("\n", einrueckung);
	}

	public static String ersterBuchstabeGross(String string) {
		if (string == null || string.length() == 0)
			return string;

		return new StringBuffer(string.length())
				.append(Character.toTitleCase(string.charAt(0)))
				.append(string.substring(1)).toString();
	}

	public static String ersterBuchstabeKlein(String string) {
		if (string == null || string.length() == 0)
			return string;

		return new StringBuffer(string.length())
				.append(Character.toLowerCase(string.charAt(0)))
				.append(string.substring(1)).toString();
	}

	static Pattern patYear = Pattern.compile("\\d\\d\\d\\d");

	public static boolean containsYear(String s) {
		Matcher m = patYear.matcher(s);
		if (m.find())
			return true;
		else
			return false;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String s = "|aaaa|**1";
		// setTeilstringVorIDN("SET:");
		System.out.println(Arrays.asList(extractIndikatorUndInhalt(s)));
	}

}
